\section{Related Work}
\label{relatedWork}
%% Begin with a brief description of Agile Software Development
Agile software development has a relatively short history.  Agile methods
were initially known as ``lightweight'' methods.  The name is in contrast 
to ``heavyweight'' methods that make use of the waterfall model.  The 
waterfall method argues for understanding user requirements followed by
designing the software, coding, and then testing~\cite{sustainable}.  
The problem with the waterfall model is the notion that all the user
requirements need to be understood before the software begins being 
created.  Hence the waterfall model is not ready 
for change whether it be updated user requirements, bug fixes, or changes to 
third party software/hardware.  

\subsection{History of Agile Software Development}
%% Give a history of Agile software, along with some of the key players
%% and the different methodologies
The agile software movement began in the mid 1990's.  Agile software development
has the ability to adapt to change fairly easily.  Kent Beck's ``lightweight'' method
known as Extreme Programming was created in 1996~\cite{extremeExplained}.  Kent Beck has
been a key player in the agile software movement in many facets.  Besides being the author
of the Extreme Programming methodology, he is also the author of JUnit, the 
Java programming language unit testing framework~\cite{junitCook}.  Kent Beck is also one of the 
original signatories of the Agile Manifesto.  

The Agile Manifesto was created in
February 2001 when seventeen people got together 
to find a common ground among all the available ``lightweight'' methodologies.  
Thus was born agile software development.  The following twelve principles were 
formed in this meeting~\cite{agileDisciplines}:
\begin{itemize}
\singlespacing
\item Satisfy the customer through early and continuous delivery of variable software
\item Sustainable development is promoted, facilitating indefinite development
\item Simplicity is essential
\item Welcome changing requirements, even late in development
\item Deliver working software frequently
\item Working software is the primary measure of progress
\item Business people and developers must work together daily
\item Face-to-face communication is the best method of conveying information
\item The team regularly reflects on how to become more productive and efficient
\item The best work emerges from self-organizing teams
\item Build projects and motivated individuals
\end{itemize}
\doublespacing

Another key player in the agile software development movement is Agile Manifesto signatory Martin Fowler.  
Fowler has authored many papers related to agile software development and posted
them on his
website. In ``The New Methodology,'' Fowler explores why agile methods
are now flourishing in the software landscape~\cite{newMethodology}.  In ``Is Design Dead?'' 
Fowler looks at design and documentation to 
determine their usefulness within
an agile software development framework~\cite{designDead}.  Fowler also looks at
the unified modeling language (UML) 
which can be used at times to fulfill design and documentation needs.  
In ``Continuous Integration'' Fowler discusses the use of an automated build process that 
includes testing to detect integration errors as quickly as possible~\cite{continuousIntegration}.  
Lastly, Fowler authored a book about refactoring code in an object-oriented technology~\cite{refactorFowler}.  
Refactoring is now considered a core practice within agile software development.  

\subsection{The Tcl Programming Language}
%% Discuss how the pragmatic programmer made use of tcl,
%% the available unit test framework for tcl and some of the work
%% done with tcl in industry
Tool command language (Tcl) is a scripting language created by John Ousterhout while at the University of California, 
Berkeley.  Tcl has simple constructs and looks very similar to the C programming language.  Currently, Tcl is at 
version 8.4.  There are a wide variety of Tcl books available, with the most recent being the Fourth edition of Brent
Welch's and Ken Jones' book~\cite{tclTk}.  The book covers up to version 8.4 of the Tcl scripting language.  It 
offers the core concepts and plenty of sample code to get a new user up to speed quickly.  

Andrew Hunt and David Thomas, also signatories of the Agile Manifesto, coauthored a book titled \underline{The Pragmatic
Programmer} in 1999~\cite{pragmaticProgrammer}.  Many of the practices outlined in the book became core disciplines of the 
agile software movement.  
One approach outlined within the book is the use of prototyping.  Prototyping software allows for analysis and the
ability to correct mistakes at a considerably lower cost.  
When prototyping software, sometimes a high-level language such as Perl or Tcl could be useful and offer quick turnaround.  
In addition, many details can be ignored, such as data types, and the prototype can still be a functional piece
of software.  Another use for Tcl is for manipulating text.  For example, Hunt
and Thomas use scripting languages for database schema
maintenance.  The language can read the database schema and generate the appropriate SQL statements to create the database.  

Tcl can also be used to build full-blown applications.  
The Jet Propulsion Laboratory (JPL) looked into using Tcl as the primary flight software for the Mars Pathfinder mission~\cite{tclMars}.  
Each subsystem of the spacecraft would instantiate its own Tcl interpreter; providing a set of commands that can be used to 
invoke other procedures within the subsystem.  Tcl offered JPL a simple syntax, easy parameter grouping, ability to return
strings from procedure calls, and variables that can be either global or local.  In the end, Tcl was not chosen as the language
of choice.  C++ was chosen and since the syntax and semantics are comparable to C, moving to C++ was not a very difficult task.  

Tcl is mainly used within a test environment.  Deutsche Telekom, Europe's largest telecom carrier and online service provider, 
makes use of a Tcl based load testing environment to ensure high quality of service and availability~\cite{tclLoadSystems}.  
One requirement for the system included a flexible, easy-to-learn scripting language for defining test scenarios.  Perl
is also a popular scripting language that was studied, but it is not as easy to pick up by test engineers.  In the end, Deutsche Telekom
found Tcl to meet the mission critical goals with minimal effort expended.  

One drawback of the Tcl scripting language is the lack of a well developed unit testing
framework.  The ``tcltest'' package
that is available with the standard Tcl distribution offers  commands useful in the construction of test suites.  The ``test'' command 
defines and runs a test.  Using ``test'' involves evaluation of a Tcl script and comparing the result to an expected result.  
The problem with this framework is that it is not an easy testing environment to use.  With only one command available, the code
used for testing is not easy to read like those of the XUnit framework~\cite{junitCook} variety.  

Toshikazu Ando, who created the TclTkUnit framework~\cite{tclTkUnit}, attempted
to.  The TclTkUnit unit test
framework
is a very good attempt at creating a unit testing framework for the Tcl
scripting language.  However, there are a few drawbacks of the 
framework.  The first issue is that comparing Tcl lists is not implemented 
within the framework.  Using lists
within Tcl is an important feature of the language.  Many times, a procedure
call will return a list of elements to the caller.  In addition, the results of running a
set of tests does not give the user good feedback after
their test has run.  If an error occurs within a suite of tests, it will show that the test failed but not give the exact location.  
A good unit test framework will give its users the proper feedback to allow them to continue updating their code or set of tests
so they can get them passing.  

\subsection{Adopting Agile within the Industry}
%% Discuss state CMMI and how agile can be used within
%% this framework of development
The agile software movement is slowly making its way into industry.  Kent Beck initially formed his ideas for Extreme Programming
as a consultant for DaimlerChrysler~\cite{extremeExplained}.  DaimlerChrysler made use of agile software processes once again
in 2004 to better serve their bus and coach business unit~\cite{breakingIce}.  The goal of their project was to improve the 
process of adding customer-specific features to the embedded software of premium buses and coaches.  Not all the agile
practices were adopted, but a set of core disciplines was put into their software ``toolbox'' to improve the process and release 
better software on time.  

Extreme Programming (XP) has also been adopted by other big process companies~\cite{extremeField}.  James Grenning acted as a
consultant to an unnamed company to build a better process for creating software.  The process that was defined was as follows:
\begin{itemize}
\singlespacing
\item Design
\item Document the design
\item Schedule review
\item Distribute the materials to review
\item Hold review
\item Close out actions
\item Update documents
\item Begin writing code
\end{itemize}
\doublespacing
The problem typically seen involved vague requirements and the need to create 
requirements documentation.  Requirements documents could not completely disappear but the documents could point to source 
code to better define the product.  In addition to creating less but better documentation, Greening pushed the company to adopt
test-driven development, continuous integration, refactoring, paired programming, and software simulation of unavailable 
hardware.  

Agile software development can be tailored to work with Capability Maturity Model Integration (CMMI)~\cite{cmmi}.  Richard Turner of
George Washington University created a presentation on how CMMI can be used to balance agile and plan-driven methods~\cite{agileCmmi}.  
Goals and practices are more flexible in CMMI, in fact, innovation at CMMI level 5 argues for agile practices.  A JPMorgan Chase
case study came to the same conclusion~\cite{xpCmmi}.  

Further, a group
from the University of Pretoria looked at how standards can be applied to agile software development~\cite{agileDevelopment}.  Standards
typically require the generation of documentation which contrasts the agile belief that working software is more important than
comprehensive documentation~\cite{newMethodology}.  Since agile methodologies are highly adaptable, they can create the necessary documentation 
to comply with standards when required.  As a result, adopting agile software practices is becoming easier within
organizations that typically require a lot of documentation and up-front design.  